import 'dart:convert';

// 定义类型为 Map -> T 的函数类型别名
typedef JsonConstructor<T> = T Function(Map<String, dynamic> json);

// 定义一个泛型接口，包含 fromJson 和 toJson
abstract class JsonSerializable {
  Map<String, dynamic> toJson();

  // 静态的全局注册表
  static final Map<String, JsonConstructor> _constructors = {};

  // 自动注册方法
  static void register<T extends JsonSerializable>(String type, JsonConstructor<T> constructor) {
    _constructors[type] = constructor;
  }

  // 根据类型名称反序列化对象
  static T fromJson<T extends JsonSerializable>(String type, Map<String, dynamic> json) {
    if (!_constructors.containsKey(type)) {
      throw Exception('No constructor registered for type $type');
    }
    return _constructors[type]!(json) as T;
  }
}

// 通用的序列化和反序列化方法
class JsonHelper {
  // 序列化支持对象、List<对象> 和 String
  static String serialize<T extends JsonSerializable>(dynamic object) {
    if (object is List<T>) {
      return jsonEncode({
        'type': T.toString(),
        'data': object.map((item) => item.toJson()).toList(),
      });
    } else if (object is JsonSerializable) {
      return jsonEncode({
        'type': T.toString(),
        'data': object.toJson(),
      });
    } else if (object is String) {
      return object; // String 直接返回
    } else {
      throw Exception("Unsupported type for serialization");
    }
  }

  // 反序列化支持对象、List<对象> 和 String
  static dynamic deserialize<T extends JsonSerializable>(String jsonString) {
    try {
      Map<String, dynamic> json = jsonDecode(jsonString);

      String type = json['type'];
      dynamic data = json['data'];

      if (data is List) {
        return data.map((item) => JsonSerializable.fromJson<T>(type, item as Map<String, dynamic>)).toList();
      } else if (data is Map<String, dynamic>) {
        return JsonSerializable.fromJson<T>(type, data);
      } else {
        throw Exception("Unsupported data format for deserialization");
      }
    } catch (e) {
      // 如果是一个普通的 String，而不是 JSON 格式
      return jsonString;
    }
  }
}
